home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1997 February / EnigmA AMIGA RUN 15 (1997)(G.R. Edizioni)(IT)[!][issue 1997-02][PLANET CD V].iso / enigma / earcd / varie / uae-0_64.lha / uae-0.6.4 / src / dos-vbe.c < prev    next >
C/C++ Source or Header  |  1996-08-18  |  48KB  |  1,731 lines
  1.  /*
  2.   * UAE - The Un*x Amiga Emulator
  3.   *
  4.   * DOS VESA BIOS / VGA / Mode X graphics interface.
  5.   *
  6.   * (c) 1995 Bernd Schmidt
  7.   * (c) 1996 Gustavo Goedert
  8.   */
  9.  
  10. #include "sysconfig.h"
  11. #include "sysdeps.h"
  12.  
  13. #include <dos.h>
  14. #include <go32.h>
  15. #include <dpmi.h>
  16. #include <sys/movedata.h>
  17. #include <sys/exceptn.h>
  18. #include <sys/farptr.h>
  19.  
  20. #include "config.h"
  21. #include "options.h"
  22. #include "memory.h"
  23. #include "custom.h"
  24. #include "newcpu.h"
  25. #include "keyboard.h"
  26. #include "xwin.h"
  27. #include "keybuf.h"
  28. #include "disk.h"
  29. #include "dos-ui.h"
  30.  
  31. #define PACKED __attribute__ ((packed))
  32. #define ALIGN(x) ((((int)(x)>>12)<<12)+4096)
  33.  
  34. static FILE *logfile;
  35.  
  36. enum VBE_MemoryModels { TextMode, CGA_Graphics, HerculesGraphics,
  37.             Planar, PackedPixel, ModeX, DirectColor, YUV } ;
  38.  
  39. typedef struct {
  40.     char VbeSignature[4] PACKED; // = VBE2
  41.     short VbeVersion PACKED;
  42.     char *OemStringPtr PACKED;
  43.     char Capabilities[4] PACKED;
  44.     unsigned int VideoModePtr PACKED;
  45.     short TotalMemory PACKED;
  46.     short OemSoftwareRev PACKED;
  47.     char *OemVendorNamePtr PACKED;
  48.     char *OemProductNamePtr PACKED;
  49.     char *OemProductRevPtr PACKED;
  50.     char Reserved[222] PACKED;
  51.     char OemData[256] PACKED;
  52. } T_VBE_VbeInfoBlock;
  53.  
  54. typedef struct {
  55.     // Mandatory information for all VBE revisions
  56.     short ModeAttributes PACKED;
  57.     char WinAAttributes PACKED;
  58.     char WinBAttributes PACKED;
  59.     short WinGranularity PACKED;
  60.     unsigned short WinSize PACKED;
  61.     unsigned short WinASegment PACKED;
  62.     unsigned short WinBSegment PACKED;
  63.     unsigned int WinFuncPtr PACKED;
  64.     short BytesPerScanLine PACKED;
  65.     // Mandatory information for VBE 1.2 and above
  66.     short XResolution PACKED;
  67.     short YResolution PACKED;
  68.     char XCharSize PACKED;
  69.     char YCharSize PACKED;
  70.     char NumberOfPlanes PACKED;
  71.     char BitsPerPixel PACKED;
  72.     char NumberOfBanks PACKED;
  73.     char MemoryModel PACKED;
  74.     char BankSize PACKED;
  75.     char NumberOfImagePages PACKED;
  76.     char ReservedA PACKED; // = 1
  77.     // Direct Color fields (required for direct/6 and YUV/7 memory models)
  78.     char RedMaskSize PACKED;
  79.     char RedFieldPosition PACKED;
  80.     char GreenMaskSize PACKED;
  81.     char GreenFieldPosition PACKED;
  82.     char BlueMaskSize PACKED;
  83.     char BlueFieldPosition PACKED;
  84.     char RsvdMaskSize PACKED;
  85.     char RsvdFieldPosition PACKED;
  86.     char DirectColorModeInfo PACKED;
  87.     // Mandatory information for VBE 2.0 and above
  88.     unsigned int PhysBasePtr PACKED;
  89.     unsigned int OffScreenMemOffset PACKED;
  90.     short OffScreenMemSize PACKED;
  91.     char ReservedB[206] PACKED;
  92. } T_VBE_ModeInfoBlock;
  93.  
  94. typedef struct {
  95.     short SetWindowOffset PACKED;
  96.     short SetDisplayStartOffset PACKED;
  97.     short SetPrimaryPaletteDataOffset PACKED;
  98.     short PortsMemoryOffset PACKED;
  99. } T_VBE_ProtectedModeInterface;
  100.  
  101. typedef enum { TText, T16, T256, T256X, T32K, T64K, T16M, TNone } T_ModeType;
  102.  
  103. typedef struct {
  104.     int ModeWidth, ModeHeight;
  105.     T_ModeType ModeType;
  106.     int BitsPerPixel;
  107.     int BitsPerColor;
  108. } T_BasicModeInfo;
  109.  
  110. typedef enum { TVBE, TVGA, TModeX } T_ControlType;
  111.  
  112. typedef struct {
  113.     T_ControlType ControlType;
  114.     int mode;
  115. } T_ControlInfo;
  116.  
  117. void SetGraphicsMode(void);
  118. void SetModeX(int num);
  119. void LoadPalette(void);
  120. int VBE_GetVbeInfoBlock(void);
  121. int VBE_GetModeInfoBlock(short mode);
  122. int VBE_GetProtectedModeInterface(void);
  123. void VBE_ChangeBankRealInterrupt(short BankNumber);
  124. void VBE_ChangeBankRealMode(short BankNumber);
  125. void VBE_ChangeBankProtectMode(short BankNumber);
  126. void DoFlushLineLinear(int y);
  127. void DoFlushLineBuffered(int y);
  128. void PutLineBanked(char *addr, int target_y);
  129. void PutLineVGA16(char *addr, int target_y);
  130. void PutLineVGAX(char *addr, int target_y);
  131.  
  132. void (*VBE_ChangeBank)(short BankNumber);
  133. void (*DoFlushLine)(int y);
  134. void (*PutLine)(char *addr, int y);
  135.  
  136. T_ControlInfo ControlInfo;
  137.  
  138. int RestoreOldVGAMode = 1, OldVGAMode;
  139.  
  140. short CurrentBankNumber = 0;
  141. short WriteWindow;
  142. unsigned short WinFuncPtrSegment, WinFuncPtrOffset;
  143.  
  144. unsigned int SetWindow;
  145. short *PortsMemory;
  146.  
  147. T_VBE_VbeInfoBlock VBE_VbeInfoBlock;
  148. T_VBE_ModeInfoBlock VBE_ModeInfoBlock;
  149. T_VBE_ProtectedModeInterface *VBE_ProtectedModeInterface;
  150. short VBE_ModeList[128];
  151.  
  152. unsigned int WinLength, WinStart;
  153. int FastWinCalc = 0;
  154. unsigned int WinMask1, WinMask2;
  155. int HasVbe = 0, HasLinear = 0;
  156. int LineLength, LogicalLineLength;
  157.  
  158. char *LinearBufferPtr;
  159. char *AlignedLinearBufferPtr;
  160.  
  161. T_BasicModeInfo BasicModeInfo;
  162. unsigned char PaletteData[768];
  163. _go32_dpmi_seginfo PaletteMem;
  164.  
  165. T_BasicModeInfo Old_VBE_Table[28] = { { 640, 400, T256, 8, 8 },
  166.                       { 640, 480, T256, 8, 8 },
  167.                       { 800, 600, T16, 8, 4 },
  168.                       { 800, 600, T256, 8, 8 },
  169.                       { 1024, 768, T16, 8, 4 },
  170.                       { 1024, 768, T256, 8, 8 },
  171.                       { 1280, 1024, T16, 8, 4 },
  172.                       { 1280, 1024, T256, 8, 8 },
  173.                       { 80, 60, TText, 0, 0 },
  174.                       { 132, 25, TText, 0, 0 },
  175.                       { 132, 43, TText, 0, 0 },
  176.                       { 132, 50, TText, 0, 0 },
  177.                       { 132, 60, TText, 0, 0 },
  178.                       { 320, 200, T32K, 16, 15 },
  179.                       { 320, 200, T64K, 16, 16 },
  180.                       { 320, 200, T16M, 24, 24 },
  181.                       { 640, 480, T32K, 16, 15 },
  182.                       { 640, 480, T64K, 16, 16 },
  183.                       { 640, 480, T16M, 24, 24 },
  184.                       { 800, 600, T32K, 16, 15 },
  185.                       { 800, 600, T64K, 16, 16 },
  186.                       { 800, 600, T16M, 24, 24 },
  187.                       { 1024, 768, T32K, 16, 15 },
  188.                       { 1024, 768, T64K, 16, 16 },
  189.                       { 1024, 768, T16M, 24, 24 },
  190.                       { 1280, 1024, T32K, 16, 15 },
  191.                       { 1280, 1024, T64K, 16, 16 },
  192.                       { 1280, 1024, T16M, 24, 24 }  };
  193.  
  194. _go32_dpmi_seginfo old_kbd_handler, new_kbd_handler, mouse_handler;
  195. _go32_dpmi_registers mouse_callback_regs;
  196.  
  197. int CorrectLines = 0;
  198.  
  199. void my_kbd_handler(void);
  200. void my_mouse_handler(_go32_dpmi_registers *mouse_regs);
  201. void HandleDisk(int num);
  202.  
  203. /* dummie Amiga Keys */
  204. #define AK_EjectDisk 0xfe
  205. #define AK_ChangeDisk 0xff
  206.  
  207. /* Command Flags */
  208. #define ResetCPU    0x001
  209. #define EjectDisk0  0x002
  210. #define EjectDisk1  0x004
  211. #define EjectDisk2  0x008
  212. #define EjectDisk3  0x010
  213. #define ChangeDisk0 0x020
  214. #define ChangeDisk1 0x040
  215. #define ChangeDisk2 0x080
  216. #define ChangeDisk3 0x100
  217.  
  218. /* PC Keys */
  219. #define SCODE_CURSORBLOCKUP    103    /* Cursor key block. */
  220. #define SCODE_CURSORBLOCKLEFT 105
  221. #define SCODE_CURSORBLOCKRIGHT 106
  222. #define SCODE_CURSORBLOCKDOWN 108
  223.  
  224. #define SCODE_INSERT 110
  225. #define SCODE_HOME 102
  226. #define SCODE_PGUP 104
  227. #define SCODE_DELETE 111
  228. #define SCODE_END 107
  229. #define SCODE_PGDN 109
  230.  
  231. #define SCODE_KEYPAD0    82
  232. #define SCODE_KEYPAD1    79
  233. #define SCODE_KEYPAD2    80
  234. #define SCODE_KEYPAD3    81
  235. #define SCODE_KEYPAD4    75
  236. #define SCODE_KEYPAD5    76
  237. #define SCODE_KEYPAD6    77
  238. #define SCODE_KEYPAD7    71
  239. #define SCODE_KEYPAD8    72
  240. #define SCODE_KEYPAD9    73
  241. #define SCODE_KEYPADENTER    96
  242. #define SCODE_KEYPADPLUS    78
  243. #define SCODE_KEYPADMINUS    74
  244.  
  245. #define SCODE_Q        16
  246. #define SCODE_W        17
  247. #define SCODE_E        18
  248. #define SCODE_R        19
  249. #define SCODE_T        20
  250. #define SCODE_Y        21
  251. #define SCODE_U        22
  252. #define SCODE_I        23
  253. #define SCODE_O        24
  254. #define SCODE_P        25
  255.  
  256. #define SCODE_A        30
  257. #define SCODE_S        31
  258. #define SCODE_D        32
  259. #define SCODE_F        33
  260. #define SCODE_G        34
  261. #define SCODE_H        35
  262. #define SCODE_J        36
  263. #define SCODE_K        37
  264. #define SCODE_L        38
  265.  
  266. #define SCODE_Z        44
  267. #define SCODE_X        45
  268. #define SCODE_C        46
  269. #define SCODE_V        47
  270. #define SCODE_B        48
  271. #define SCODE_N        49
  272. #define SCODE_M        50
  273.  
  274. #define SCODE_ESCAPE        1
  275. #define SCODE_ENTER        28
  276. #define SCODE_RIGHTCONTROL    97
  277. #define SCODE_CONTROL    97
  278. #define SCODE_RIGHTALT    100
  279. #define SCODE_LEFTCONTROL    29
  280. #define SCODE_LEFTALT    56
  281. #define SCODE_SPACE        57
  282.  
  283. #define SCODE_F1        59
  284. #define SCODE_F2        60
  285. #define SCODE_F3        61
  286. #define SCODE_F4        62
  287. #define SCODE_F5        63
  288. #define SCODE_F6        64
  289. #define SCODE_F7        65
  290. #define SCODE_F8        66
  291. #define SCODE_F9        67
  292. #define SCODE_F10        68
  293.  
  294. #define KEY_EVENTRELEASE 0
  295. #define KEY_EVENTPRESS 1
  296.  
  297. #define SCODE_0 11
  298. #define SCODE_1 2
  299. #define SCODE_2 3
  300. #define SCODE_3 4
  301. #define SCODE_4 5
  302. #define SCODE_5 6
  303. #define SCODE_6 7
  304. #define SCODE_7 8
  305. #define SCODE_8 9
  306. #define SCODE_9 10
  307.  
  308. #define SCODE_LEFTSHIFT 42
  309. #define SCODE_RIGHTSHIFT 54
  310. #define SCODE_TAB 15
  311.  
  312. #define SCODE_F11 87
  313. #define SCODE_F12 88
  314. #define SCODE_NEXT 81
  315. #define SCODE_PRIOR 73
  316. #define SCODE_BS 14
  317. /*
  318. #define SCODE_asciicircum 1
  319. */
  320. #define SCODE_bracketleft 26
  321. #define SCODE_bracketright 27
  322. #define SCODE_comma 51
  323. #define SCODE_period 52
  324. #define SCODE_slash 53
  325. #define SCODE_semicolon 39
  326. #define SCODE_grave 40
  327. #define SCODE_minus 12
  328. #define SCODE_equal 13
  329. #define SCODE_numbersign 41
  330. #define SCODE_ltgt 43
  331. #define SCODE_scrolllock 70
  332.  
  333. #define SCODE_LWIN95 125
  334. #define SCODE_RWIN95 126
  335. #define SCODE_MWIN95 127
  336.  
  337. #define SCODE_Caps_Lock 58
  338.  
  339. static unsigned char escape_keys[128] = {
  340.   0,            0,            0,        0,
  341.   0,             0,            0,        0,
  342.   0,             0,            0,        0,
  343.   0,             0,            0,        0,
  344.   0,             0,            0,        0,
  345.   0,             0,            0,        0,
  346.   0,            0,            0,        0,
  347.   SCODE_KEYPADENTER,    SCODE_RIGHTCONTROL,    0,        0,
  348.   0,             0,            0,        0,
  349.   0,             0,            0,        0,
  350.   0,             0,            0,        0,
  351.   0,             0,            0,        0,
  352.   0,             0,            0,        0,
  353.   0,             0,            0,        0,
  354.   0,             0,            0,        0,
  355.   0,             0,            0,        0,
  356.   0,             0,            0,        0,
  357.   0,            0,             0,        SCODE_HOME,
  358.   SCODE_CURSORBLOCKUP,    SCODE_PGUP,        0,        SCODE_CURSORBLOCKLEFT,
  359.   0,            SCODE_CURSORBLOCKRIGHT,    0,        SCODE_END,
  360.   SCODE_CURSORBLOCKDOWN,SCODE_PGDN,        SCODE_INSERT,    SCODE_DELETE,
  361.   0,            0,            0,        0,
  362.   0,            0,            0,        SCODE_LWIN95,
  363.   SCODE_RWIN95,        SCODE_MWIN95,        0,        0,
  364.   0,            0,            0,        0,
  365.   0,            0,            0,        0,
  366.   0,            0,            0,        0,
  367.   0,            0,            0,        0,
  368.   0,            0,            0,        0,
  369.   0,            0,            0,        0,
  370.   0,            0,            0,        0,
  371.   0,            0,            0,        0
  372. };
  373.  
  374. static int vsize;
  375. static int CommandFlags = 0;
  376. static int need_dither;
  377.  
  378. static UBYTE dither_buf[1000];
  379.  
  380. xcolnr xcolors[4096];
  381.  
  382. struct vidbuf_description gfxvidinfo;
  383.  
  384. void flush_line(int y)
  385. {
  386.     DoFlushLine(y);
  387. }
  388.  
  389. void flush_block(int a, int b)
  390. {
  391.     abort();
  392. }
  393.  
  394. void flush_screen(int a, int b)
  395. {
  396. }
  397.  
  398. void calc_adjustment(void)
  399. {
  400.     switch (screen_res) {
  401.      case 0: case 1: case 2: /* LoRes, 320xfoo */
  402.     gfxvidinfo.x_adjust = prev_max_diwstop - 320;
  403.     break;
  404.  
  405.      case 3: /* 640xbar */
  406.     gfxvidinfo.x_adjust = prev_max_diwstop - 640;
  407.     break;
  408.      default:
  409.     gfxvidinfo.x_adjust = 0;
  410.     break;
  411.     }
  412. }
  413.  
  414. static int colors_allocated;
  415.  
  416. unsigned char PaletteData[768];
  417.  
  418. static int get_color(int r, int g, int b, xcolnr *cnp)
  419. {
  420.     _go32_dpmi_registers regs;
  421.  
  422.     if (colors_allocated == 256)
  423.     return -1;
  424.     *cnp = colors_allocated;
  425.     PaletteData[colors_allocated*3+0] = doMask(r, 6, 0);
  426.     PaletteData[colors_allocated*3+1] = doMask(g, 6, 0);
  427.     PaletteData[colors_allocated*3+2] = doMask(b, 6, 0);
  428.     colors_allocated++;
  429.     return 1;
  430. }
  431.  
  432. static void init_colors(void)
  433. {
  434.     if (need_dither) {
  435.     setup_dither(BasicModeInfo.BitsPerColor, get_color);
  436.     } else {
  437.     colors_allocated = 0;
  438.     if (gfxvidinfo.pixbytes == 1)
  439.         alloc_colors256(get_color);
  440.     else
  441.         alloc_colors64k(VBE_ModeInfoBlock.RedMaskSize,
  442.                 VBE_ModeInfoBlock.GreenMaskSize,
  443.                 VBE_ModeInfoBlock.BlueMaskSize,
  444.                 VBE_ModeInfoBlock.RedFieldPosition,
  445.                 VBE_ModeInfoBlock.GreenFieldPosition,
  446.                 VBE_ModeInfoBlock.BlueFieldPosition);
  447.    }
  448. }
  449.  
  450. int buttonstate[3] = { 0, 0, 0 };
  451. int lastmx, lastmy;
  452. int newmousecounters = 0;
  453.  
  454. static int keystate[256];
  455.  
  456. static int scancode2amiga(int scancode)
  457. {
  458.     switch(scancode) {
  459.      case SCODE_A: return AK_A;
  460.      case SCODE_B: return AK_B;
  461.      case SCODE_C: return AK_C;
  462.      case SCODE_D: return AK_D;
  463.      case SCODE_E: return AK_E;
  464.      case SCODE_F: return AK_F;
  465.      case SCODE_G: return AK_G;
  466.      case SCODE_H: return AK_H;
  467.      case SCODE_I: return AK_I;
  468.      case SCODE_J: return AK_J;
  469.      case SCODE_K: return AK_K;
  470.      case SCODE_L: return AK_L;
  471.      case SCODE_M: return AK_M;
  472.      case SCODE_N: return AK_N;
  473.      case SCODE_O: return AK_O;
  474.      case SCODE_P: return AK_P;
  475.      case SCODE_Q: return AK_Q;
  476.      case SCODE_R: return AK_R;
  477.      case SCODE_S: return AK_S;
  478.      case SCODE_T: return AK_T;
  479.      case SCODE_U: return AK_U;
  480.      case SCODE_V: return AK_V;
  481.      case SCODE_W: return AK_W;
  482.      case SCODE_X: return AK_X;
  483.      case SCODE_Y: return AK_Y;
  484.      case SCODE_Z: return AK_Z;
  485.  
  486.      case SCODE_0: return AK_0;
  487.      case SCODE_1: return AK_1;
  488.      case SCODE_2: return AK_2;
  489.      case SCODE_3: return AK_3;
  490.      case SCODE_4: return AK_4;
  491.      case SCODE_5: return AK_5;
  492.      case SCODE_6: return AK_6;
  493.      case SCODE_7: return AK_7;
  494.      case SCODE_8: return AK_8;
  495.      case SCODE_9: return AK_9;
  496.  
  497.      case SCODE_KEYPAD0: return AK_NP0;
  498.      case SCODE_KEYPAD1: return AK_NP1;
  499.      case SCODE_KEYPAD2: return AK_NP2;
  500.      case SCODE_KEYPAD3: return AK_NP3;
  501.      case SCODE_KEYPAD4: return AK_NP4;
  502.      case SCODE_KEYPAD5: return AK_NP5;
  503.      case SCODE_KEYPAD6: return AK_NP6;
  504.      case SCODE_KEYPAD7: return AK_NP7;
  505.      case SCODE_KEYPAD8: return AK_NP8;
  506.      case SCODE_KEYPAD9: return AK_NP9;
  507.  
  508.      case SCODE_F1: return AK_F1;
  509.      case SCODE_F2: return AK_F2;
  510.      case SCODE_F3: return AK_F3;
  511.      case SCODE_F4: return AK_F4;
  512.      case SCODE_F5: return AK_F5;
  513.      case SCODE_F6: return AK_F6;
  514.      case SCODE_F7: return AK_F7;
  515.      case SCODE_F8: return AK_F8;
  516.      case SCODE_F9: return AK_F9;
  517.      case SCODE_F10: return AK_F10;
  518.  
  519.      case SCODE_BS: return AK_BS;
  520.      case SCODE_LEFTCONTROL: return AK_CTRL;
  521.      case SCODE_RIGHTCONTROL: return AK_CTRL;
  522.      case SCODE_TAB: return AK_TAB;
  523.      case SCODE_LEFTALT: return AK_LALT;
  524.      case SCODE_RIGHTALT: return AK_RALT;
  525.      case SCODE_ENTER: return AK_RET;
  526.      case SCODE_SPACE: return AK_SPC;
  527.      case SCODE_LEFTSHIFT: return AK_LSH;
  528.      case SCODE_RIGHTSHIFT: return AK_RSH;
  529.      case SCODE_ESCAPE: return AK_ESC;
  530.  
  531.      case SCODE_INSERT: break;
  532. /*     case SCODE_END:
  533.      case SCODE_HOME: break;*/
  534.  
  535.      case SCODE_DELETE: return AK_DEL;
  536.      case SCODE_CURSORBLOCKUP: return AK_UP;
  537.      case SCODE_CURSORBLOCKDOWN: return AK_DN;
  538.      case SCODE_CURSORBLOCKLEFT: return AK_LF;
  539.      case SCODE_CURSORBLOCKRIGHT: return AK_RT;
  540.  
  541.      case SCODE_F11: return AK_BACKSLASH;
  542. /*
  543.      case SCODE_asciicircum: return AK_00;
  544.  */
  545.      case SCODE_bracketleft: return AK_LBRACKET;
  546.      case SCODE_bracketright: return AK_RBRACKET;
  547.      case SCODE_comma: return AK_COMMA;
  548.      case SCODE_period: return AK_PERIOD;
  549.      case SCODE_slash: return AK_SLASH;
  550.      case SCODE_semicolon: return AK_SEMICOLON;
  551.      case SCODE_grave: return AK_QUOTE;
  552.      case SCODE_minus: return AK_MINUS;
  553.      case SCODE_equal: return AK_EQUAL;
  554.  
  555.     /* This one turns off screen updates. */
  556.      case SCODE_scrolllock: return AK_inhibit;
  557.  
  558.      case SCODE_PGUP: case SCODE_RWIN95: return AK_RAMI;
  559.      case SCODE_PGDN: case SCODE_LWIN95: return AK_LAMI;
  560.  
  561. /*#ifdef KBD_LANG_DE*/
  562.      case SCODE_numbersign: return AK_NUMBERSIGN;
  563.      case SCODE_ltgt: return AK_LTGT;
  564. /*#endif*/
  565.      case SCODE_END: return AK_EjectDisk;
  566.      case SCODE_HOME: return AK_ChangeDisk;
  567.     }
  568.     return -1;
  569. }
  570.  
  571. void my_kbd_handler(void)
  572. {
  573.     static int is_escape = 0;
  574.     int scancode, newstate, akey;
  575.     scancode = inportb(0x60);
  576.     if (scancode == 0xe0) {
  577.     is_escape = 1;
  578.     outportb(0x20, 0x20);
  579.     return;
  580.     }
  581.     newstate = !(scancode & 0x80);
  582.     scancode = scancode & 0x7f;
  583.     if (is_escape) {
  584.     scancode = escape_keys[scancode];
  585.     is_escape = 0;
  586.     }
  587.     outportb(0x20, 0x20);
  588.  
  589.     akey = scancode2amiga(scancode);
  590.     if (scancode == SCODE_Caps_Lock) {
  591.     if (newstate == KEY_EVENTPRESS) {
  592.         akey = AK_CAPSLOCK;
  593.         newstate = !keystate[akey];
  594.     } else
  595.         return;
  596.     }
  597.     if (scancode == SCODE_F12) {
  598.     specialflags |= SPCFLAG_BRK;
  599.     quit_program = 1;
  600.     }
  601.  
  602.     if (akey == -1)
  603.     return;
  604.     if (akey <= 0xFF) {
  605.     if (keystate[akey] == newstate)
  606.         return;
  607.     keystate[akey] = newstate;
  608.     }
  609.  
  610.     if ((akey != AK_EjectDisk) && (akey != AK_ChangeDisk)) {
  611.     if (newstate == KEY_EVENTPRESS) {
  612.     if (akey == AK_inhibit)
  613.         inhibit_frame ^= 1;
  614.     else
  615.         record_key (akey << 1);
  616.     } else
  617.     record_key ((akey << 1) | 1);
  618.     }
  619.  
  620.     /* "Affengriff" */
  621.     if (keystate[AK_CTRL] && keystate[AK_LAMI] && keystate[AK_RAMI])
  622.     CommandFlags |= ResetCPU;
  623.     if (keystate[AK_EjectDisk]) {
  624.     if (keystate[AK_F1])
  625.         CommandFlags |= EjectDisk0;
  626.     if (keystate[AK_F2])
  627.         CommandFlags |= EjectDisk1;
  628.     if (keystate[AK_F3])
  629.         CommandFlags |= EjectDisk2;
  630.     if (keystate[AK_F4])
  631.         CommandFlags |= EjectDisk3;
  632.     }
  633.     if (keystate[AK_ChangeDisk]) {
  634.     if (keystate[AK_F1])
  635.         CommandFlags |= ChangeDisk0;
  636.     if (keystate[AK_F2])
  637.         CommandFlags |= ChangeDisk1;
  638.     if (keystate[AK_F3])
  639.         CommandFlags |= ChangeDisk2;
  640.     if (keystate[AK_F4])
  641.         CommandFlags |= ChangeDisk3;
  642.     }
  643. }
  644.  
  645. void my_mouse_handler(_go32_dpmi_registers *mouse_regs)
  646. {
  647.     lastmx = (short)mouse_regs->x.si;
  648.     lastmy = (short)mouse_regs->x.di;
  649.     buttonstate[0] = mouse_regs->x.bx & 1;
  650.     buttonstate[1] = mouse_regs->x.bx & 4;
  651.     buttonstate[2] = mouse_regs->x.bx & 2;
  652. }
  653.  
  654. int graphics_init(void)
  655. {
  656.     int i;
  657.     _go32_dpmi_registers regs;
  658.     extern int kpb_first, kpb_last;
  659.     extern int keybuf[256];
  660.     int WantedWidth, WantedHeight;
  661.     T_ModeType WantedType;
  662.     int FoundMode;
  663.     int VideoMemorySize, ExtraVideoMemorySize;
  664.  
  665.     /* small check and setup */
  666.     remove("uae.log");
  667.     if(ersatzkickfile && disk_empty(0)) {
  668.     fprintf (stderr, "No KickStart and no bootdisk, giving up.\n");
  669.     return 0;
  670.     }
  671.     _go32_want_ctrl_break(1);
  672.     __djgpp_set_ctrl_c(0);
  673.  
  674.     /* set up keyboard handler */
  675.     _go32_dpmi_get_protected_mode_interrupt_vector(9, &old_kbd_handler);
  676.     new_kbd_handler.pm_offset = (int)my_kbd_handler;
  677.     if (_go32_dpmi_allocate_iret_wrapper(&new_kbd_handler) != 0) {
  678.     fprintf (stderr, "Can't allocate keyboard iret_wrapper.\n");
  679.     return 0;
  680.     }
  681.     if (_go32_dpmi_set_protected_mode_interrupt_vector(9, &new_kbd_handler) != 0) {
  682.     fprintf (stderr, "Can't set protected mode interrupt vector.\n");
  683.     return 0;
  684.     }
  685.  
  686.     /* set up mouse handler */
  687.     regs.x.ax=0;
  688.     regs.x.ss=regs.x.sp=regs.x.flags=0;
  689.     _go32_dpmi_simulate_int(0x33, ®s);
  690.     if (regs.x.ax==0) {
  691.     fprintf (stderr, "Mouse driver not present.\n");
  692.     return 0;
  693.     }
  694.     mouse_handler.pm_offset = (int)my_mouse_handler;
  695.     if (_go32_dpmi_allocate_real_mode_callback_retf(&mouse_handler, &mouse_callback_regs) != 0) {
  696.     fprintf (stderr, "Can't allocate mouse callback_retf.\n");
  697.     return 0;
  698.     }
  699.     regs.x.ax=0xc;
  700.     regs.x.cx=0x7f;
  701.     regs.x.es=mouse_handler.rm_segment;
  702.     regs.x.dx=mouse_handler.rm_offset;
  703.     regs.x.ss=regs.x.sp=regs.x.flags=0;
  704.     _go32_dpmi_simulate_int(0x33, ®s);
  705.  
  706.     /* Save Old VGA Mode */
  707.     regs.x.ax = 0x1C;
  708.     regs.h.ah = 0x0F;
  709.     regs.x.ss=regs.x.sp=regs.x.flags=0;
  710.     _go32_dpmi_simulate_int(0x10, ®s);
  711.     OldVGAMode = regs.h.al;
  712.  
  713.     /* Allocate Palette Memory */
  714.     PaletteMem.size = 48;
  715.     if (_go32_dpmi_allocate_dos_memory(&PaletteMem)) {
  716.     fprintf (stderr, "Can't allocate real mode memory for palette data.\n");
  717.     return 0;
  718.     }
  719.  
  720.     if (correct_aspect)
  721.     CorrectLines = 1;
  722.     if (screen_res < 2)
  723.     correct_aspect = 0;
  724.  
  725.     /* set up wanted video mode information */
  726.     switch (color_mode) {
  727.      case 0: WantedType=T256; need_dither=0; break;
  728.      case 1: WantedType=T32K; need_dither=0; break;
  729.      case 2: WantedType=T64K; need_dither=0; break;
  730.      case 3: WantedType=T256; need_dither=1; break;
  731.      case 4: WantedType=T16;  need_dither=1; break;
  732.      case 5: WantedType=T16M; need_dither=0; break;
  733.      default:
  734.     fprintf(stderr, "Invalid color mode.\n");
  735.     return 0;
  736.     }
  737.     switch (screen_res) {
  738.      case 0: WantedWidth=320; WantedHeight=200; break;
  739.      case 1: WantedWidth=320; WantedHeight=240; break;
  740.      case 2: WantedWidth=320; WantedHeight=400; break;
  741.      case 3: WantedWidth=640; WantedHeight=480; break;
  742.      case 4: WantedWidth=800; WantedHeight=600; break;
  743.      default:
  744.     fprintf(stderr, "Invalid screen mode.\n");
  745.     return 0;
  746.     }
  747.  
  748.     FoundMode = 0;
  749.  
  750.     /* check for vbe */
  751.     HasVbe = VBE_GetVbeInfoBlock();
  752.  
  753.     if (HasVbe) {
  754.     unsigned int dosmempos = (VBE_VbeInfoBlock.VideoModePtr >> 16) * 16 +
  755.                  (VBE_VbeInfoBlock.VideoModePtr & 0xffff);
  756.     dosmemget(dosmempos, 256, VBE_ModeList);
  757.     VBE_ModeList[127] = -1;
  758.     for (i=0; (VBE_ModeList[i] != -1) && (!FoundMode) ; i++) {
  759.         if ((VBE_ModeList[i] != (short)0x81ff) && VBE_GetModeInfoBlock(VBE_ModeList[i])) {
  760.         if ((VBE_VbeInfoBlock.VbeVersion < 0x0200) && (VBE_ModeList[i] == 0x6a)) {
  761.             BasicModeInfo.ModeWidth = 800;
  762.             BasicModeInfo.ModeHeight = 600;
  763.             BasicModeInfo.ModeType = T16;
  764.             BasicModeInfo.BitsPerColor = 4;
  765.             BasicModeInfo.BitsPerPixel = 8;
  766.             VBE_ModeInfoBlock.BitsPerPixel = 8;
  767.         } else if ((VBE_VbeInfoBlock.VbeVersion < 0x0200) && ((VBE_ModeList[i] >= 0x100) && (VBE_ModeList[i] <= 0x11b)))
  768.             BasicModeInfo = Old_VBE_Table[VBE_ModeList[i] - 0x100];
  769.         else {
  770.             if (VBE_VbeInfoBlock.VbeVersion < 0x0102) {
  771.             if (VBE_ModeInfoBlock.MemoryModel == PackedPixel) {
  772.                 if (VBE_ModeInfoBlock.BitsPerPixel == 16) {
  773.                 VBE_ModeInfoBlock.MemoryModel = DirectColor;
  774.                 VBE_ModeInfoBlock.RedMaskSize = 5;
  775.                 VBE_ModeInfoBlock.RedFieldPosition = 10;
  776.                 VBE_ModeInfoBlock.GreenMaskSize = 5;
  777.                 VBE_ModeInfoBlock.GreenFieldPosition = 5;
  778.                 VBE_ModeInfoBlock.BlueMaskSize = 5;
  779.                 VBE_ModeInfoBlock.BlueFieldPosition = 0;
  780.                 VBE_ModeInfoBlock.RsvdMaskSize = 1;
  781.                 VBE_ModeInfoBlock.RsvdFieldPosition = 15;
  782.                 } else if (VBE_ModeInfoBlock.BitsPerPixel == 24) {
  783.                 VBE_ModeInfoBlock.MemoryModel = DirectColor;
  784.                 VBE_ModeInfoBlock.RedMaskSize = 8;
  785.                 VBE_ModeInfoBlock.RedFieldPosition = 16;
  786.                 VBE_ModeInfoBlock.GreenMaskSize = 8;
  787.                 VBE_ModeInfoBlock.GreenFieldPosition = 8;
  788.                 VBE_ModeInfoBlock.BlueMaskSize = 8;
  789.                 VBE_ModeInfoBlock.BlueFieldPosition = 0;
  790.                 VBE_ModeInfoBlock.RsvdMaskSize = 0;
  791.                 VBE_ModeInfoBlock.RsvdFieldPosition = 0;
  792.                 } else if (VBE_ModeInfoBlock.BitsPerPixel == 32) {
  793.                 VBE_ModeInfoBlock.MemoryModel = DirectColor;
  794.                 VBE_ModeInfoBlock.RedMaskSize = 8;
  795.                 VBE_ModeInfoBlock.RedFieldPosition = 16;
  796.                 VBE_ModeInfoBlock.GreenMaskSize = 8;
  797.                 VBE_ModeInfoBlock.GreenFieldPosition = 8;
  798.                 VBE_ModeInfoBlock.BlueMaskSize = 8;
  799.                 VBE_ModeInfoBlock.BlueFieldPosition = 0;
  800.                 VBE_ModeInfoBlock.RsvdMaskSize = 8;
  801.                 VBE_ModeInfoBlock.RsvdFieldPosition = 24;
  802.                 }
  803.             }
  804.             }
  805.             BasicModeInfo.ModeWidth = VBE_ModeInfoBlock.XResolution;
  806.             BasicModeInfo.ModeHeight = VBE_ModeInfoBlock.YResolution;
  807.             if ((VBE_ModeInfoBlock.MemoryModel == PackedPixel) && (VBE_ModeInfoBlock.BitsPerPixel == 8)) {
  808.             BasicModeInfo.ModeType = T256;
  809.             BasicModeInfo.BitsPerColor = 8;
  810.             VBE_ModeInfoBlock.BitsPerPixel = 8;
  811.             } else if (VBE_ModeInfoBlock.MemoryModel == DirectColor) {
  812.             int BitsperColor = VBE_ModeInfoBlock.RedMaskSize+VBE_ModeInfoBlock.GreenMaskSize+VBE_ModeInfoBlock.BlueMaskSize;
  813.             if (BitsperColor == 15) {
  814.                 BasicModeInfo.ModeType = T32K;
  815.                 VBE_ModeInfoBlock.BitsPerPixel = 16;
  816.             } else if (BitsperColor == 16) {
  817.                 BasicModeInfo.ModeType = T64K;
  818.                 VBE_ModeInfoBlock.BitsPerPixel = 16;
  819.             } else if (BitsperColor == 24) {
  820.                 BasicModeInfo.ModeType = T16M;
  821.                 if (VBE_ModeInfoBlock.RsvdMaskSize == 8)
  822.                 VBE_ModeInfoBlock.BitsPerPixel = 32;
  823.                 else
  824.                 VBE_ModeInfoBlock.BitsPerPixel = 24;
  825.             } else
  826.                 BasicModeInfo.ModeType = TNone;
  827.             BasicModeInfo.BitsPerColor = BitsperColor;
  828.             } else if (VBE_ModeInfoBlock.MemoryModel == Planar) {
  829.             BasicModeInfo.ModeType = T16;
  830.             BasicModeInfo.BitsPerColor = 4;
  831.             VBE_ModeInfoBlock.BitsPerPixel = 8;
  832.             } else
  833.             BasicModeInfo.ModeType = TNone;
  834.         }
  835.         if ((BasicModeInfo.ModeType == T256) || (BasicModeInfo.ModeType == T16))
  836.             VBE_ModeInfoBlock.BitsPerPixel = 8;
  837.         BasicModeInfo.BitsPerPixel = VBE_ModeInfoBlock.BitsPerPixel;
  838.         if (WantedWidth == BasicModeInfo.ModeWidth &&
  839.             WantedHeight == BasicModeInfo.ModeHeight &&
  840.             WantedType == BasicModeInfo.ModeType) {
  841.             FoundMode = 1;
  842.         }
  843.         }
  844.         if (FoundMode && (VBE_ModeInfoBlock.ModeAttributes & 1)) {
  845.         HasLinear = 0;
  846.         if ((VBE_ModeInfoBlock.ModeAttributes & (1<<7)) && !use_xhair && (VBE_ModeInfoBlock.MemoryModel != Planar)) {
  847.             if (screen_res<4)
  848.             ExtraVideoMemorySize = VBE_ModeInfoBlock.BytesPerScanLine * 8;
  849.             else
  850.             ExtraVideoMemorySize = 0;
  851.             VideoMemorySize = ALIGN(VBE_ModeInfoBlock.BytesPerScanLine * VBE_ModeInfoBlock.YResolution);
  852.             LinearBufferPtr = malloc(VideoMemorySize + ExtraVideoMemorySize);
  853.             if (LinearBufferPtr != NULL) {
  854.             AlignedLinearBufferPtr = (char *) ALIGN(LinearBufferPtr + ExtraVideoMemorySize);
  855.             if (!__djgpp_map_physical_memory(AlignedLinearBufferPtr, VideoMemorySize, VBE_ModeInfoBlock.PhysBasePtr))
  856.                 HasLinear = 1;
  857.             else
  858.                 free(LinearBufferPtr);
  859.             }
  860.             if (HasLinear) {
  861.             regs.x.ax = 0x4F02;
  862.             regs.x.bx = VBE_ModeList[i] | (1<<14);
  863.             regs.x.ss=regs.x.sp=regs.x.flags=0;
  864.             _go32_dpmi_simulate_int(0x10, ®s);
  865.             ControlInfo.ControlType = TVBE;
  866.             ControlInfo.mode = VBE_ModeList[i] | (1<<14);
  867.             DoFlushLine = DoFlushLineLinear;
  868.             }
  869.         }
  870.         if (!HasLinear) {
  871.             if (!(VBE_ModeInfoBlock.ModeAttributes & (1<<6))) {
  872.             regs.x.ax = 0x4F02;
  873.             regs.x.bx = VBE_ModeList[i];
  874.             regs.x.ss=regs.x.sp=regs.x.flags=0;
  875.             _go32_dpmi_simulate_int(0x10, ®s);
  876.             ControlInfo.ControlType = TVBE;
  877.             ControlInfo.mode = VBE_ModeList[i];
  878.             if ((VBE_VbeInfoBlock.VbeVersion >= 0x0200) && VBE_GetProtectedModeInterface()) {
  879. /*                Test memory need for linear memory selector*/
  880.                 VBE_ChangeBank = VBE_ChangeBankProtectMode;
  881.             } else if (VBE_ModeInfoBlock.WinFuncPtr != 0) {
  882.                 WinFuncPtrSegment = VBE_ModeInfoBlock.WinFuncPtr >> 16;
  883.                 WinFuncPtrOffset = VBE_ModeInfoBlock.WinFuncPtr & 0xffff;
  884.                 VBE_ChangeBank = VBE_ChangeBankRealMode;
  885.             } else
  886.                 VBE_ChangeBank = VBE_ChangeBankRealInterrupt;
  887.             WinLength = VBE_ModeInfoBlock.WinSize * 1024;
  888.             if (VBE_ModeInfoBlock.WinAAttributes & 4) {
  889.                 WinStart = VBE_ModeInfoBlock.WinASegment * 16;
  890.                 WriteWindow = 0;
  891.             } else {
  892.                 WinStart = VBE_ModeInfoBlock.WinBSegment * 16;
  893.                 WriteWindow = 1;
  894.             }
  895.             for (i=1; i<32; i++) {
  896.                 if (((unsigned int) 1<<i) == WinLength) {
  897.                 FastWinCalc = 1;
  898.                 WinMask1 = i;
  899.                 WinMask2 = WinLength-1;
  900.                 break;
  901.                 }
  902.             }
  903.             DoFlushLine = DoFlushLineBuffered;
  904.             if (VBE_ModeInfoBlock.MemoryModel != Planar)
  905.                 PutLine = PutLineBanked;
  906.             else
  907.                 PutLine = PutLineVGA16;
  908.             } else
  909.             FoundMode = 0;
  910.         }
  911.         LineLength = (VBE_ModeInfoBlock.BitsPerPixel >> 3) * BasicModeInfo.ModeWidth;
  912.         LogicalLineLength = VBE_ModeInfoBlock.BytesPerScanLine;
  913.         }
  914.     }
  915.     }
  916.  
  917.     if (!FoundMode) {
  918.     if (screen_res==0) {
  919.         if (WantedType == T256) {
  920.         BasicModeInfo.ModeWidth=320;
  921.         BasicModeInfo.ModeHeight=200;
  922.         BasicModeInfo.ModeType=T256;
  923.         BasicModeInfo.BitsPerPixel=8;
  924.         BasicModeInfo.BitsPerColor=8;
  925.         ExtraVideoMemorySize = 2560;
  926.         VideoMemorySize = ALIGN(64000);
  927.         LinearBufferPtr = malloc(VideoMemorySize + ExtraVideoMemorySize);
  928.         if (LinearBufferPtr != NULL) {
  929.             AlignedLinearBufferPtr = (char *) ALIGN(LinearBufferPtr + ExtraVideoMemorySize);
  930.             if (!__djgpp_map_physical_memory(AlignedLinearBufferPtr, VideoMemorySize, 0xa0000))
  931.             HasLinear = 1;
  932.             else
  933.             free(LinearBufferPtr);
  934.         }
  935.         if (HasLinear)
  936.             DoFlushLine = DoFlushLineLinear;
  937.         else {
  938.             WinLength = 65536;
  939.             WinStart = 0xa0000;
  940.             FastWinCalc = 1;
  941.             WinMask1 = 16;
  942.             WinMask2 = WinLength-1;
  943.             DoFlushLine = DoFlushLineBuffered;
  944.             PutLine = PutLineBanked;
  945.         }
  946.         regs.h.ah = 0x00;
  947.         regs.h.al = 0x13;
  948.         regs.x.ss=regs.x.sp=regs.x.flags=0;
  949.         _go32_dpmi_simulate_int(0x10, ®s);
  950.         ControlInfo.ControlType = TVGA;
  951.         ControlInfo.mode = 0x13;
  952.         LineLength = 320;
  953.         LogicalLineLength = 320;
  954.         FoundMode = 1;
  955.         } else if (WantedType == T16) {
  956.         BasicModeInfo.ModeWidth=320;
  957.         BasicModeInfo.ModeHeight=200;
  958.         BasicModeInfo.ModeType=T16;
  959.         BasicModeInfo.BitsPerPixel=8;
  960.         BasicModeInfo.BitsPerColor=4;
  961.         WinLength = 65536;
  962.         WinStart = 0xa0000;
  963.         DoFlushLine = DoFlushLineBuffered;
  964.         PutLine = PutLineVGA16;
  965.         regs.h.ah = 0x00;
  966.         regs.h.al = 0xd;
  967.         regs.x.ss=regs.x.sp=regs.x.flags=0;
  968.         _go32_dpmi_simulate_int(0x10, ®s);
  969.         ControlInfo.ControlType = TVGA;
  970.         ControlInfo.mode = 0xd;
  971.         LineLength = 40;
  972.         LogicalLineLength = 40;
  973.         FoundMode = 1;
  974.         }
  975.     } else if ((screen_res==1) && (WantedType=T256)) {
  976.         BasicModeInfo.ModeWidth=320;
  977.         BasicModeInfo.ModeHeight=240;
  978.         BasicModeInfo.ModeType=T256X;
  979.         BasicModeInfo.BitsPerPixel=8;
  980.         BasicModeInfo.BitsPerColor=8;
  981.         WinLength = 65536;
  982.         WinStart = 0xa0000;
  983.         DoFlushLine = DoFlushLineBuffered;
  984.         PutLine = PutLineVGAX;
  985.         ControlInfo.ControlType = TModeX;
  986.         ControlInfo.mode = 1;
  987.         LineLength = 80;
  988.         LogicalLineLength = 80;
  989.         SetModeX(1);
  990.         FoundMode = 1;
  991.     } else if ((screen_res==2) && (WantedType=T256)) {
  992.         BasicModeInfo.ModeWidth=320;
  993.         BasicModeInfo.ModeHeight=400;
  994.         BasicModeInfo.ModeType=T256X;
  995.         BasicModeInfo.BitsPerPixel=8;
  996.         BasicModeInfo.BitsPerColor=8;
  997.         WinLength = 65536;
  998.         WinStart = 0xa0000;
  999.         DoFlushLine = DoFlushLineBuffered;
  1000.         PutLine = PutLineVGAX;
  1001.         ControlInfo.ControlType = TModeX;
  1002.         ControlInfo.mode = 2;
  1003.         LineLength = 80;
  1004.         LogicalLineLength = 80;
  1005.         SetModeX(2);
  1006.         FoundMode = 1;
  1007.     } if ((screen_res==3) && (WantedType == T16)) {
  1008.         BasicModeInfo.ModeWidth=640;
  1009.         BasicModeInfo.ModeHeight=480;
  1010.         BasicModeInfo.ModeType=T16;
  1011.         BasicModeInfo.BitsPerPixel=8;
  1012.         BasicModeInfo.BitsPerColor=4;
  1013.         WinLength = 65536;
  1014.         WinStart = 0xa0000;
  1015.         DoFlushLine = DoFlushLineBuffered;
  1016.         PutLine = PutLineVGA16;
  1017.         regs.h.ah = 0x00;
  1018.         regs.h.al = 0x12;
  1019.         regs.x.ss=regs.x.sp=regs.x.flags=0;
  1020.         _go32_dpmi_simulate_int(0x10, ®s);
  1021.         ControlInfo.ControlType = TVGA;
  1022.         ControlInfo.mode = 0x12;
  1023.         LineLength = 80;
  1024.         LogicalLineLength = 80;
  1025.         FoundMode = 1;
  1026.     }
  1027.     }
  1028.  
  1029.     if (!FoundMode) {
  1030.     RestoreOldVGAMode = 0;
  1031.     fprintf(stderr, "Sorry, this combination of color and video mode is not available.\n");
  1032.     return 0;
  1033.     }
  1034.  
  1035.     logfile = freopen("UAE.LOG", "w", stderr);
  1036.  
  1037.     if (HasVbe) {
  1038.     fprintf (stderr, "VESA BIOS Extension version %d.%d found.\n", VBE_VbeInfoBlock.VbeVersion >> 8, VBE_VbeInfoBlock.VbeVersion & 0xFF);
  1039.     if (HasLinear)
  1040.         fprintf (stderr, "Using Linear FrameBuffer.\n");
  1041.     if (VBE_ChangeBank == VBE_ChangeBankProtectMode)
  1042.         fprintf (stderr, "Using Protected Mode Bank Switch Function.\n");
  1043.     if (VBE_ChangeBank == VBE_ChangeBankRealMode)
  1044.         fprintf (stderr, "Using Real Mode Bank Switch Function.\n");
  1045.     if (VBE_ChangeBank == VBE_ChangeBankRealInterrupt)
  1046.         fprintf (stderr, "Using Real Mode Bank Switch Interrupt Function.\n");
  1047.     } else {
  1048.     fprintf (stderr, "Using normal VGA hardware.\n");
  1049.     if (HasLinear)
  1050.         fprintf (stderr, "Using Linear FrameBuffer. (vga memory fits on a single segment)\n");
  1051.     if (screen_res>0)
  1052.         fprintf (stderr, "Using VGA Mode X.\n");
  1053.     }
  1054.  
  1055.     if (!need_dither)
  1056.     gfxvidinfo.pixbytes = (BasicModeInfo.BitsPerPixel >> 3);
  1057.     else
  1058.     gfxvidinfo.pixbytes = 2;
  1059.  
  1060.     vsize = correct_aspect ? 2*numscrlines : numscrlines;
  1061.     gfxvidinfo.maxblocklines = 0;
  1062.  
  1063.     if (HasLinear)
  1064.     HasLinear = !need_dither;
  1065.     if (HasLinear) {
  1066.     gfxvidinfo.rowbytes = LogicalLineLength;
  1067.     if (correct_aspect) {
  1068.         if (screen_res == 4) {
  1069.         gfxvidinfo.bufmem = AlignedLinearBufferPtr + (15 * LogicalLineLength);
  1070.         gfxvidinfo.maxline = 585;
  1071.         } else {
  1072.         gfxvidinfo.bufmem = AlignedLinearBufferPtr - (8 * LogicalLineLength);
  1073.         gfxvidinfo.maxline = BasicModeInfo.ModeHeight + 8;
  1074.         }
  1075.     } else {
  1076.         if (screen_res == 4) {
  1077.         gfxvidinfo.bufmem = AlignedLinearBufferPtr + (157 * LogicalLineLength);
  1078.         gfxvidinfo.maxline = 443;
  1079.         } else if (screen_res == 3) {
  1080.         gfxvidinfo.bufmem = AlignedLinearBufferPtr + (97 * LogicalLineLength);
  1081.         gfxvidinfo.maxline = 383;
  1082.         } else if (screen_res == 2) {
  1083.         gfxvidinfo.bufmem = AlignedLinearBufferPtr + (57 * LogicalLineLength);
  1084.         gfxvidinfo.maxline = 343;
  1085.         } else {
  1086.         gfxvidinfo.bufmem = AlignedLinearBufferPtr - (8 * LogicalLineLength);
  1087.         gfxvidinfo.maxline = BasicModeInfo.ModeHeight + 8;
  1088.         }
  1089.     }
  1090.     } else {
  1091.     gfxvidinfo.rowbytes = BasicModeInfo.ModeWidth * gfxvidinfo.pixbytes;
  1092.     gfxvidinfo.bufmem = malloc(gfxvidinfo.rowbytes * vsize);
  1093.     memset(gfxvidinfo.bufmem, 0, gfxvidinfo.rowbytes * vsize);
  1094.     gfxvidinfo.maxline = vsize;
  1095.     }
  1096.  
  1097.     gfxvidinfo.maxlinetoscr = BasicModeInfo.ModeWidth < 800 ? BasicModeInfo.ModeWidth : 0;
  1098.     gfxvidinfo.x_adjust = 0;
  1099.  
  1100.     init_colors();
  1101.     dosmemput(PaletteData, 768, PaletteMem.rm_segment*16);
  1102.     LoadPalette();
  1103.  
  1104.     buttonstate[0] = buttonstate[1] = buttonstate[2] = 0;
  1105.     for(i = 0; i < 256; i++)
  1106.     keystate[i] = 0;
  1107.  
  1108.     lastmx = lastmy = 0;
  1109.     newmousecounters = 0;
  1110.  
  1111.     /* Lock Data Touched by Interrup Handlers */
  1112.     _go32_dpmi_lock_code(scancode2amiga, (unsigned int)graphics_init-(unsigned int)scancode2amiga);
  1113.     _go32_dpmi_lock_data(escape_keys, sizeof(escape_keys));
  1114.     _go32_dpmi_lock_data(®s, sizeof(regs));
  1115.     _go32_dpmi_lock_data(keystate, sizeof(keystate));
  1116.     _go32_dpmi_lock_data(&CommandFlags, sizeof(CommandFlags));
  1117.     _go32_dpmi_lock_data(&lastmx, sizeof(lastmx));
  1118.     _go32_dpmi_lock_data(&lastmy, sizeof(lastmy));
  1119.     _go32_dpmi_lock_data(buttonstate, sizeof(buttonstate));
  1120.     _go32_dpmi_lock_data(&old_kbd_handler, sizeof(old_kbd_handler));
  1121.     _go32_dpmi_lock_data(&new_kbd_handler, sizeof(new_kbd_handler));
  1122.     _go32_dpmi_lock_data(&mouse_handler, sizeof(mouse_handler));
  1123.     _go32_dpmi_lock_data(&mouse_callback_regs, sizeof(mouse_callback_regs));
  1124.     _go32_dpmi_lock_code(record_key, (unsigned int)keybuf_init-(unsigned int)record_key);
  1125.     _go32_dpmi_lock_data(&kpb_first, sizeof(kpb_first));
  1126.     _go32_dpmi_lock_data(&kpb_last, sizeof(kpb_last));
  1127.     _go32_dpmi_lock_data(keybuf, sizeof(keybuf));
  1128.  
  1129.     return 1;
  1130. }
  1131.  
  1132. void graphics_leave(void)
  1133. {
  1134.     _go32_dpmi_registers regs;
  1135.  
  1136.     if (RestoreOldVGAMode) {
  1137.     FILE *fp;
  1138.     int inChar;
  1139.  
  1140.     regs.x.ax = 0x1C;
  1141.     regs.h.ah = 0x00;
  1142.     regs.h.al = OldVGAMode;
  1143.     regs.x.ss=regs.x.sp=regs.x.flags=0;
  1144.     _go32_dpmi_simulate_int(0x10, ®s);
  1145.     fclose(logfile);
  1146.     freopen("CON", "w", stderr);
  1147.     
  1148.     fp = fopen("uae.log","r");
  1149.     for (;;) {
  1150.         inChar = getc(fp);
  1151.         if (inChar == EOF)
  1152.         break;
  1153.         putchar(inChar);
  1154.     }
  1155.     fclose(fp);
  1156.     }
  1157.     _go32_dpmi_set_protected_mode_interrupt_vector(9, &old_kbd_handler);
  1158.     _go32_dpmi_free_iret_wrapper(&new_kbd_handler);
  1159.     regs.x.ax=0xc;
  1160.     regs.x.cx=0x0;
  1161.     regs.x.ss=regs.x.sp=regs.x.flags=0;
  1162.     _go32_dpmi_simulate_int(0x33, ®s);
  1163.     _go32_dpmi_free_real_mode_callback(&mouse_handler);
  1164.     _go32_dpmi_free_dos_memory(&PaletteMem);
  1165. }
  1166.  
  1167. void handle_events(void)
  1168. {
  1169.     if (CommandFlags) {
  1170.     if (CommandFlags & ResetCPU) {
  1171.         m68k_reset();
  1172.         CommandFlags &= ~ResetCPU;
  1173.     }
  1174.     if (CommandFlags & EjectDisk0) {
  1175.         disk_eject(0);
  1176.         CommandFlags &= ~EjectDisk0;
  1177.     }
  1178.     if (CommandFlags & EjectDisk1) {
  1179.         disk_eject(1);
  1180.         CommandFlags &= ~EjectDisk1;
  1181.     }
  1182.     if (CommandFlags & EjectDisk2) {
  1183.         disk_eject(2);
  1184.         CommandFlags &= ~EjectDisk2;
  1185.     }
  1186.     if (CommandFlags & EjectDisk3) {
  1187.         disk_eject(3);
  1188.         CommandFlags &= ~EjectDisk3;
  1189.     }
  1190.     if (CommandFlags & ChangeDisk0) {
  1191.         HandleDisk(0);
  1192.         keystate[AK_ChangeDisk] = 0;
  1193.         keystate[AK_F1] = 0;
  1194.         record_key ((AK_F1 << 1) | 1);
  1195.         CommandFlags &= ~ChangeDisk0;
  1196.     }
  1197.     if (CommandFlags & ChangeDisk1) {
  1198.         HandleDisk(1);
  1199.         keystate[AK_ChangeDisk] = 0;
  1200.         keystate[AK_F2] = 0;
  1201.         record_key ((AK_F2 << 1) | 1);
  1202.         CommandFlags &= ~ChangeDisk1;
  1203.     }
  1204.     if (CommandFlags & ChangeDisk2) {
  1205.         HandleDisk(2);
  1206.         keystate[AK_ChangeDisk] = 0;
  1207.         keystate[AK_F3] = 0;
  1208.         record_key ((AK_F3 << 1) | 1);
  1209.         CommandFlags &= ~ChangeDisk2;
  1210.     }
  1211.     if (CommandFlags & ChangeDisk3) {
  1212.         HandleDisk(3);
  1213.         keystate[AK_ChangeDisk] = 0;
  1214.         keystate[AK_F4] = 0;
  1215.         record_key ((AK_F4 << 1) | 1);
  1216.         CommandFlags &= ~ChangeDisk3;
  1217.     }
  1218.     }
  1219. }
  1220.  
  1221. int debuggable(void)
  1222. {
  1223.     return 0;
  1224. }
  1225.  
  1226. int needmousehack(void)
  1227. {
  1228.     return 0;
  1229. }
  1230.  
  1231. void LED(int on)
  1232. {
  1233. }
  1234.  
  1235. void target_specific_usage(void)
  1236. {
  1237.     printf("  -S                       : Turn off sound support (if it is configured)\n");
  1238.     printf("  -l lang                  : Set keyboard language to lang, where lang is\n"
  1239.        "                             DE or US\n");
  1240.     printf("  -x                       : Don't use linear framebuffer, even if available.\n");
  1241.     printf("  -p filename              : Use filename to save printer output (i.e. PRN)\n");
  1242.     printf("  -I device                : Name of the used serial device (i.e. AUX)\n");
  1243.     printf("  -8                       : Use 8 Bit Sound (default is 16 Bit Sound)\n");
  1244.     printf("  -4                       : Use 44100Hz Samplerate (default is 22050Hz)\n");
  1245. }
  1246.  
  1247. void HandleDisk(int num)
  1248. {
  1249.     int i, memsize = 0;
  1250.     char buf[256], *save_mem = NULL;
  1251.     _go32_dpmi_registers regs;
  1252.  
  1253.     _go32_dpmi_set_protected_mode_interrupt_vector(9, &old_kbd_handler);
  1254.  
  1255.     if (HasLinear) {
  1256.     memsize = LogicalLineLength * BasicModeInfo.ModeHeight;
  1257.     save_mem = malloc(memsize);
  1258.     if (save_mem != NULL)
  1259.         memcpy(save_mem, AlignedLinearBufferPtr, memsize);
  1260.     }
  1261.     /* Set text mode */
  1262.     regs.x.ax = 0x1C;
  1263.     regs.h.ah = 0x00;
  1264.     regs.h.al = 0x03;
  1265.     regs.x.ss=regs.x.sp=regs.x.flags=0;
  1266.     _go32_dpmi_simulate_int(0x10, ®s);
  1267.  
  1268.     strcpy(buf,dosfilereq("*.adf"));
  1269.     disk_insert(num, buf);
  1270.  
  1271.     _go32_dpmi_set_protected_mode_interrupt_vector(9, &new_kbd_handler);
  1272.  
  1273.     /* Set graphics mode */
  1274.     SetGraphicsMode();
  1275.     /* Restore screen */
  1276.     if ((gfxvidinfo.pixbytes == 1) || need_dither)
  1277.     LoadPalette();
  1278.     if (HasLinear) {
  1279.     if (save_mem != NULL) {
  1280.         memcpy(AlignedLinearBufferPtr, save_mem, memsize);
  1281.         free(save_mem);
  1282.     }
  1283.     } else {
  1284.     for(i=0; i<vsize; i++)
  1285.         flush_line(i);
  1286.     }
  1287. }
  1288.  
  1289. void SetGraphicsMode(void) {
  1290.     _go32_dpmi_registers regs;
  1291.  
  1292.     switch(ControlInfo.ControlType) {
  1293.     case TVBE:
  1294.         VBE_GetModeInfoBlock(ControlInfo.mode);
  1295.         regs.x.ax = 0x4F02;
  1296.         regs.x.bx = ControlInfo.mode;
  1297.         regs.x.ss=regs.x.sp=regs.x.flags=0;
  1298.         _go32_dpmi_simulate_int(0x10, ®s);
  1299.         break;
  1300.     case TVGA:
  1301.         regs.h.ah = 0x00;
  1302.         regs.h.al = ControlInfo.mode;
  1303.         regs.x.ss=regs.x.sp=regs.x.flags=0;
  1304.         _go32_dpmi_simulate_int(0x10, ®s);
  1305.         break;
  1306.     case TModeX:
  1307.         SetModeX(ControlInfo.mode);
  1308.         break;
  1309.     }
  1310. }
  1311.  
  1312. void SetModeX(int num) {
  1313.     _go32_dpmi_registers regs;
  1314.     int i;
  1315.     char cleared[320];
  1316.  
  1317.     regs.h.ah = 0x00;
  1318.     regs.h.al = 0x13;
  1319.     regs.x.ss=regs.x.sp=regs.x.flags=0;
  1320.     _go32_dpmi_simulate_int(0x10, ®s);
  1321.     for (i=0; i<320; i++)
  1322.     cleared[i] = 0;
  1323.     outportw(0x3c4, 0x604);
  1324.     if (num==1) {
  1325.     outportw(0x3c4, 0x0100);
  1326.     outportb(0x3c2, 0x00e3);
  1327.     outportw(0x3c4, 0x0300);
  1328.     outportw(0x3d4, 0x2c11);
  1329.     outportw(0x3d4, 0x5f00);
  1330.     outportw(0x3d4, 0x4f01);
  1331.     outportw(0x3d4, 0x5002);
  1332.     outportw(0x3d4, 0x8203);
  1333.     outportw(0x3d4, 0x5404);
  1334.     outportw(0x3d4, 0x8005);
  1335.     outportw(0x3d4, 0x0d06);
  1336.     outportw(0x3d4, 0x3e07);
  1337.     outportw(0x3d4, 0x0008);
  1338.     outportw(0x3d4, 0x4109);
  1339.     outportw(0x3d4, 0x000a);
  1340.     outportw(0x3d4, 0x000b);
  1341.     outportw(0x3d4, 0x000c);
  1342.     outportw(0x3d4, 0x000d);
  1343.     outportw(0x3d4, 0x000e);
  1344.     outportw(0x3d4, 0x000f);
  1345.     outportw(0x3d4, 0xea10);
  1346.     outportw(0x3d4, 0xac11);
  1347.     outportw(0x3d4, 0xdf12);
  1348.     outportw(0x3d4, 0x2813);
  1349.     outportw(0x3d4, 0x0014);
  1350.     outportw(0x3d4, 0xe715);
  1351.     outportw(0x3d4, 0x0616);
  1352.     outportw(0x3d4, 0xe317);
  1353.     for (i=0; i<240; i++)
  1354.         PutLineVGAX(cleared, i);
  1355.     } else {
  1356.     outportw(0x3d4, 0x0e11);
  1357.     outportw(0x3d4, 0x5f00);
  1358.     outportw(0x3d4, 0x4f01);
  1359.     outportw(0x3d4, 0x5002);
  1360.     outportw(0x3d4, 0x8203);
  1361.     outportw(0x3d4, 0x5404);
  1362.     outportw(0x3d4, 0x8005);
  1363.     outportw(0x3d4, 0xbf06);
  1364.     outportw(0x3d4, 0x1f07);
  1365.     outportw(0x3d4, 0x0008);
  1366.     outportw(0x3d4, 0x4009);
  1367.     outportw(0x3d4, 0x000a);
  1368.     outportw(0x3d4, 0x000b);
  1369.     outportw(0x3d4, 0x000c);
  1370.     outportw(0x3d4, 0x000d);
  1371.     outportw(0x3d4, 0x000e);
  1372.     outportw(0x3d4, 0x000f);
  1373.     outportw(0x3d4, 0x9c10);
  1374.     outportw(0x3d4, 0x8e11);
  1375.     outportw(0x3d4, 0x8f12);
  1376.     outportw(0x3d4, 0x2813);
  1377.     outportw(0x3d4, 0x0014);
  1378.     outportw(0x3d4, 0x9615);
  1379.     outportw(0x3d4, 0xb916);
  1380.     outportw(0x3d4, 0xe317);
  1381.     for (i=0; i<400; i++)
  1382.         PutLineVGAX(cleared, i);
  1383.     }
  1384. }
  1385.  
  1386. void LoadPalette(void) {
  1387.     _go32_dpmi_registers regs;
  1388.  
  1389.     regs.h.ah = 0x10;
  1390.     regs.h.al = 0x12;
  1391.     regs.x.bx = 0;
  1392.     if (BasicModeInfo.ModeType == T16)
  1393.     regs.x.cx = 16;
  1394.     else
  1395.     regs.x.cx = 256;
  1396.     regs.x.es = PaletteMem.rm_segment;
  1397.     regs.x.dx = 0x0000;
  1398.     regs.x.ss=regs.x.sp=regs.x.flags=0;
  1399.     _go32_dpmi_simulate_int(0x10, ®s);
  1400. }
  1401.  
  1402.  
  1403. int VBE_GetVbeInfoBlock(void) {
  1404.     _go32_dpmi_registers regs;
  1405.  
  1406.     strncpy(VBE_VbeInfoBlock.VbeSignature, "VBE2", 4);
  1407.     dosmemput(&VBE_VbeInfoBlock, sizeof(VBE_VbeInfoBlock), __tb);
  1408.     regs.x.ax = 0x4F00;
  1409.     regs.x.di = __tb & 0x0F;
  1410.     regs.x.es = (__tb >> 4) & 0xFFFF;
  1411.     regs.x.ss=regs.x.sp=regs.x.flags=0;
  1412.     _go32_dpmi_simulate_int(0x10, ®s);
  1413.     dosmemget(__tb, sizeof(VBE_VbeInfoBlock), &VBE_VbeInfoBlock);
  1414.     return((regs.x.ax == 0x004F) && (VBE_VbeInfoBlock.VbeVersion >= 0x0100));
  1415. }
  1416.  
  1417. int VBE_GetModeInfoBlock(short mode) {
  1418.     _go32_dpmi_registers regs;
  1419.  
  1420.     VBE_ModeInfoBlock.ReservedA = 1;
  1421.     regs.x.ax = 0x4F01;
  1422.     regs.x.cx = mode;
  1423.     regs.x.di = __tb & 0x0F;
  1424.     regs.x.es = (__tb >> 4) & 0xFFFF;
  1425.     regs.x.ss=regs.x.sp=regs.x.flags=0;
  1426.     _go32_dpmi_simulate_int(0x10, ®s);
  1427.     dosmemget(__tb, sizeof(VBE_ModeInfoBlock), &VBE_ModeInfoBlock);
  1428.     return(regs.x.ax == 0x004F);
  1429. }
  1430.  
  1431. int VBE_GetProtectedModeInterface(void) {
  1432.     _go32_dpmi_registers regs;
  1433.  
  1434.     regs.x.ax = 0x4F0A;
  1435.     regs.x.bx = 0x0000;
  1436.     regs.x.ss=regs.x.sp=regs.x.flags=0;
  1437.     _go32_dpmi_simulate_int(0x10, ®s);
  1438.     VBE_ProtectedModeInterface = (T_VBE_ProtectedModeInterface *) malloc(regs.x.cx);
  1439.     if (VBE_ProtectedModeInterface == NULL)
  1440.     return(0);
  1441.     dosmemget(regs.x.es * 16 + regs.x.di, regs.x.cx, VBE_ProtectedModeInterface);
  1442.     SetWindow = (unsigned int) VBE_ProtectedModeInterface + VBE_ProtectedModeInterface->SetWindowOffset;
  1443.     PortsMemory = (short *) VBE_ProtectedModeInterface + VBE_ProtectedModeInterface->PortsMemoryOffset;
  1444.     return(regs.x.ax == 0x004F);
  1445. }
  1446.  
  1447. void VBE_ChangeBankRealInterrupt(short BankNumber) {
  1448.     _go32_dpmi_registers regs;
  1449.  
  1450.     regs.x.ax = 0x4F05;
  1451.     regs.x.bx = WriteWindow;
  1452.     regs.x.dx = BankNumber;
  1453.     regs.x.ss=regs.x.sp=regs.x.flags=0;
  1454.     _go32_dpmi_simulate_int(0x10, ®s);
  1455.     CurrentBankNumber = BankNumber;
  1456. }
  1457.  
  1458. void VBE_ChangeBankRealMode(short BankNumber) {
  1459.     _go32_dpmi_registers regs;
  1460.  
  1461.     regs.x.ax = 0x4F05;
  1462.     regs.x.bx = WriteWindow;
  1463.     regs.x.dx = BankNumber;
  1464.     regs.x.cs = WinFuncPtrSegment;
  1465.     regs.x.ip = WinFuncPtrOffset;
  1466.     regs.x.ss=regs.x.sp=regs.x.flags=0;
  1467.     _go32_dpmi_simulate_fcall(®s);
  1468.     CurrentBankNumber = BankNumber;
  1469. }
  1470.  
  1471. void VBE_ChangeBankProtectMode(short BankNumber) {
  1472.     asm ("
  1473.      push %%es
  1474.      movw %0, %%es
  1475.      mov 0x4F05, %%ax
  1476.      mov %1, %%bx
  1477.      mov %2, %%dx
  1478.      call %3
  1479.       pop %%es
  1480.      "
  1481.      :
  1482.      : "g" (_dos_ds), "g" (WriteWindow), "g" (BankNumber), "r" (SetWindow)
  1483.      : "%ax", "%bx", "%dx"
  1484.     );
  1485.     CurrentBankNumber = BankNumber;
  1486. }
  1487.  
  1488. void DoFlushLineLinear(int y) {
  1489.     int target_y;
  1490.     char *addr;
  1491.  
  1492.     if (need_dither) {
  1493.     target_y = y;
  1494.     switch (screen_res) {
  1495.      case 0:
  1496.         if (CorrectLines) {
  1497.         if (target_y%3==0)
  1498.             return;
  1499.         target_y=(target_y<<1)/3+5;
  1500.         } else
  1501.         target_y -= 8;
  1502.         break;
  1503.      case 1:
  1504.         if (CorrectLines) {
  1505.         if (target_y%5==0)
  1506.             return;
  1507.         target_y=(target_y<<2)/5+6;
  1508.         } else
  1509.         target_y -= 8;
  1510.         break;
  1511.      case 2:
  1512.         if (CorrectLines) {
  1513.         if (target_y%3==0)
  1514.             return;
  1515.         target_y=(target_y<<1)/3+10;
  1516.         } else
  1517.         target_y += 57;
  1518.         break;
  1519.      case 3:
  1520.         if (CorrectLines) {
  1521.         if (target_y%5==0)
  1522.             return;
  1523.         target_y=(target_y<<2)/5+12;
  1524.         } else
  1525.         target_y += 97;
  1526.         break;
  1527.      case 4:
  1528.         if (CorrectLines)
  1529.         target_y += 15;
  1530.         else
  1531.         target_y += 157;
  1532.         break;
  1533.     }
  1534.     if (target_y < BasicModeInfo.ModeHeight && target_y >= 0) {
  1535.         addr = gfxvidinfo.bufmem + y*gfxvidinfo.rowbytes;
  1536.         DitherLine(AlignedLinearBufferPtr + LogicalLineLength * target_y, (UWORD *)addr, 0, y, BasicModeInfo.ModeWidth, BasicModeInfo.BitsPerPixel);
  1537.     }
  1538.     }
  1539. }
  1540.  
  1541. void DoFlushLineBuffered(int y) {
  1542.     int target_y = y;
  1543.     char *addr;
  1544.  
  1545.     switch (screen_res) {
  1546.      case 0:
  1547.     if (CorrectLines) {
  1548.         if (target_y%3==0)
  1549.         return;
  1550.         target_y=(target_y<<1)/3+5;
  1551.     } else
  1552.         target_y -= 8;
  1553.     break;
  1554.      case 1:
  1555.     if (CorrectLines) {
  1556.         if (target_y%5==0)
  1557.         return;
  1558.         target_y=(target_y<<2)/5+6;
  1559.     } else
  1560.         target_y -= 8;
  1561.     break;
  1562.      case 2:
  1563.     if (CorrectLines) {
  1564.         if (target_y%3==0)
  1565.         return;
  1566.         target_y=(target_y<<1)/3+10;
  1567.     } else
  1568.         target_y += 57;
  1569.     break;
  1570.      case 3:
  1571.     if (CorrectLines) {
  1572.         if (target_y%5==0)
  1573.         return;
  1574.         target_y=(target_y<<2)/5+12;
  1575.     } else
  1576.         target_y += 97;
  1577.     break;
  1578.      case 4:
  1579.     if (CorrectLines)
  1580.         target_y += 15;
  1581.     else
  1582.         target_y += 157;
  1583.     break;
  1584.     }
  1585.     if (target_y < BasicModeInfo.ModeHeight && target_y >= 0) {
  1586.     addr = gfxvidinfo.bufmem + y*gfxvidinfo.rowbytes;
  1587.     if (need_dither) {
  1588.         DitherLine(dither_buf, (UWORD *)addr, 0, y, BasicModeInfo.ModeWidth, BasicModeInfo.BitsPerPixel);
  1589.         addr = dither_buf;
  1590.     }
  1591.     PutLine(addr, target_y);
  1592.     }
  1593. }
  1594.  
  1595. void PutLineBanked(char *addr, int target_y) {
  1596.     unsigned int offs;
  1597.     int page, pos, left;
  1598.     char *ptr;
  1599.  
  1600.     offs = target_y * LogicalLineLength;
  1601.     if (FastWinCalc) {
  1602.     page = offs >> WinMask1;
  1603.     pos = offs & WinMask2;
  1604.     } else {
  1605.     page = offs / WinLength;
  1606.     pos = offs % WinLength;
  1607.     }
  1608.     left = WinLength - pos;
  1609.     ptr = (char *) WinStart + pos;
  1610.     if (page != CurrentBankNumber)
  1611.     VBE_ChangeBank(page);
  1612.     if (left >= LineLength)
  1613.     asm __volatile__ ("
  1614.          push %%es
  1615.          cld
  1616.          movw %0, %%es
  1617.          shrl $2, %%ecx
  1618.          rep
  1619.          movsl
  1620.          pop %%es
  1621.          "
  1622.          :
  1623.          : "g" (_dos_ds), "S" (addr), "D" (ptr), "c" (LineLength)
  1624.          : "%esi", "%edi", "%ecx", "cc", "memory"
  1625.     );
  1626.     else {
  1627.     asm __volatile__ ("
  1628.          push %%es
  1629.          cld
  1630.          movw %0, %%es
  1631.          shrl $2, %%ecx
  1632.          rep
  1633.          movsl
  1634.          pop %%es
  1635.          "
  1636.          :
  1637.          : "g" (_dos_ds), "S" (addr), "D" (ptr), "c" (left)
  1638.          : "%esi", "%edi", "%ecx", "cc", "memory"
  1639.     );
  1640.     VBE_ChangeBank(page+1);
  1641.     asm __volatile__ ("
  1642.          push %%es
  1643.          cld
  1644.          movw %0, %%es
  1645.          addl %1, %%esi
  1646.          subl %1, %%ecx
  1647.          shrl $2, %%ecx
  1648.          rep
  1649.          movsl
  1650.          pop %%es
  1651.          "
  1652.          :
  1653.          : "g" (_dos_ds), "g" (left), "S" (addr), "D" (WinStart), "c" (LineLength)
  1654.          : "%esi", "%edi", "%ecx", "cc", "memory"
  1655.     );
  1656.     }
  1657. }
  1658.  
  1659. void PutLineVGA16(char *addr, int target_y) {
  1660.     unsigned int start, ptr;
  1661.     int i;
  1662.     UBYTE c;
  1663.  
  1664.     _farsetsel(_dos_ds);
  1665. #if 0
  1666.     ptr = WinStart + target_y * LogicalLineLength;
  1667.     outportw(0x3ce, 0x205);
  1668.     outportw(0x3ce, 3);
  1669.     for (i=0; i<BasicModeInfo.ModeWidth; i++) {
  1670.     outportw(0x3ce, 1<<(((i&7)^7)+8)|8);
  1671.     _farnspeekb(ptr+(i>>3));
  1672.     _farnspokeb(ptr+(i>>3), addr[i]);
  1673.     }
  1674. #else
  1675.     start = WinStart + target_y * LogicalLineLength;
  1676.     ptr = start;
  1677.     outportw(0x3c4, 0x802);
  1678.     for (i=0; i<BasicModeInfo.ModeWidth; i+=8, ptr++) {
  1679.     c = ((addr[i  ]<<4)&128)|((addr[i+1]<<3)&64)|((addr[i+2]<<2)&32)|((addr[i+3]<<1)&16)|
  1680.         ((addr[i+4]   )&8  )|((addr[i+5]>>1)&4 )|((addr[i+6]>>2)&2 )|((addr[i+7]>>3)&1);
  1681.     _farnspokeb(ptr, c);
  1682.     }
  1683.     ptr = start;
  1684.     outportw(0x3c4, 0x402);
  1685.     for (i=0; i<BasicModeInfo.ModeWidth; i+=8, ptr++) {
  1686.     c = ((addr[i  ]<<5)&128)|((addr[i+1]<<4)&64)|((addr[i+2]<<3)&32)|((addr[i+3]<<2)&16)|
  1687.         ((addr[i+4]<<1)&8  )|((addr[i+5]   )&4 )|((addr[i+6]>>1)&2 )|((addr[i+7]>>2)&1 );
  1688.     _farnspokeb(ptr, c);
  1689.     }
  1690.     ptr = start;
  1691.     outportw(0x3c4, 0x202);
  1692.     for (i=0; i<BasicModeInfo.ModeWidth; i+=8, ptr++) {
  1693.     c = ((addr[i  ]<<6)&128)|((addr[i+1]<<5)&64)|((addr[i+2]<<4)&32)|((addr[i+3]<<3)&16)|
  1694.         ((addr[i+4]<<2)&8  )|((addr[i+5]<<1)&4 )|((addr[i+6]   )&2 )|((addr[i+7]>>1)&1 );
  1695.     _farnspokeb(ptr, c);
  1696.     }
  1697.     ptr = start;
  1698.     outportw(0x3c4, 0x102);
  1699.     for (i=0; i<BasicModeInfo.ModeWidth; i+=8, ptr++) {
  1700.     c = ((addr[i  ]<<7)&128)|((addr[i+1]<<6)&64)|((addr[i+2]<<5)&32)|((addr[i+3]<<4)&16)|
  1701.         ((addr[i+4]<<3)&8  )|((addr[i+5]<<2)&4 )|((addr[i+6]<<1)&2 )|((addr[i+7]   )&1 );
  1702.     _farnspokeb(ptr, c);
  1703.     }
  1704. #endif
  1705. }
  1706.  
  1707. void PutLineVGAX(char *addr, int target_y) {
  1708.     unsigned int start, ptr;
  1709.     int i;
  1710.     UBYTE c;
  1711.  
  1712.     _farsetsel(_dos_ds);
  1713.     start = WinStart + target_y * LogicalLineLength;
  1714.     ptr = start;
  1715.     outportw(0x3c4, 0x102);
  1716.     for (i=0; i<BasicModeInfo.ModeWidth; i+=4, ptr++)
  1717.     _farnspokeb(ptr, addr[i]);
  1718.     ptr = start;
  1719.     outportw(0x3c4, 0x202);
  1720.     for (i=1; i<BasicModeInfo.ModeWidth; i+=4, ptr++)
  1721.     _farnspokeb(ptr, addr[i]);
  1722.     ptr = start;
  1723.     outportw(0x3c4, 0x402);
  1724.     for (i=2; i<BasicModeInfo.ModeWidth; i+=4, ptr++)
  1725.     _farnspokeb(ptr, addr[i]);
  1726.     ptr = start;
  1727.     outportw(0x3c4, 0x802);
  1728.     for (i=3; i<BasicModeInfo.ModeWidth; i+=4, ptr++)
  1729.     _farnspokeb(ptr, addr[i]);
  1730. }
  1731.